{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Quantitative Finance\n",
    "\n",
    "Copyright (c) 2019 Python Charmers Pty Ltd, Australia, <https://pythoncharmers.com>. All rights reserved.\n",
    "\n",
    "<img src=\"img/python_charmers_logo.png\" width=\"300\" alt=\"Python Charmers Logo\">\n",
    "\n",
    "Published under the Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0) license. See `LICENSE.md` for details.\n",
    "\n",
    "Sponsored by Tibra Global Services, <https://tibra.com>\n",
    "\n",
    "<img src=\"img/tibra_logo.png\" width=\"300\" alt=\"Tibra Logo\">\n",
    "\n",
    "\n",
    "## Module 1.3: Ordinary Least Squares\n",
    "\n",
    "### 1.3.2 Multivariate OLS\n",
    "\n",
    "In the previous module, we looked at the Ordinary Least Squares (OLS) method for solving Linear Regression problems of the form:\n",
    "\n",
    "$ Y = X\\beta + \\boldsymbol{u}$\n",
    "\n",
    "Where $Y$ is the variable we are attempting to predict (the dependent variable), $X$ is our independent variable (or multiple variables, as we will see in the next notebook), $\\beta$ is the parameters we are trying to learn, and $u$ is the error of our model, as we can often not predict data perfectly.\n",
    "\n",
    "In that previous module, we had just a single input variable (and added another for the constant). Most models have many, many more, including in some cases combinations of features (such as multiplying two feature values together). Multivariate OLS allows this. For instance, we might try and predict a stock price by taking the stock price of several competitors as input.\n",
    "\n",
    "The actual equation for OLS doesn't change. Instead, our understanding of the components ($Y$, $X$, $\\beta$ and $u$) does. Rather than be single vectors or single values, they are instead matrices and vectors.\n",
    "\n",
    "For those unfamiliar with matrix algebra, we will take a quick detour through this topic, before linking it back to Multivariate OLS at the end of this module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run setup.ipy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix Algebra\n",
    "\n",
    "Matrices are used for a very wide range of applications. They are rectangular collections of numbers, and follow several rules on multiplying, adding, dividing and other actions. There are a few differences from algebra in more \"standard\" mathematics, for instance $A \\times B \\neq B \\times A$ in most cases.\n",
    "\n",
    "In matrix algebra, single values still exist, known as *scalars*:\n",
    "\n",
    "Mathematically: $a = 1$.\n",
    "\n",
    "In code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On notation, as it is important going forward, a scalar is almost always written as a standard lowercase letter (specifically, not bold, as we will see soon).\n",
    "\n",
    "For an ordered list of values, denoted a *vector* in matrix algebra, we use a bold lowercase letter. We can't bold our variable names in Python, so we will just continue to use lowercase letters. If you want to distinguish, some use an underscore: `_u`\n",
    "\n",
    "Mathematically: $\\boldsymbol{u} = [0.1, 0.3, 4.6]$\n",
    "\n",
    "In code, for the NumPy library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "u = np.array([0.1, 0.3, 4.6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For rectangular groups of numbers, known as a **matrix**, we use an uppercase letter:\n",
    "\n",
    "Mathematically:\n",
    "\n",
    "$ X = \\begin{bmatrix}\n",
    "1 & 2 \\\\\n",
    "3 & 4 \\\\\n",
    "5 & 6 \n",
    "\\end{bmatrix}  $\n",
    "\n",
    "\n",
    "In code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.array([\n",
    "    [1, 2],\n",
    "    [3, 4],\n",
    "    [5, 6]\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In NumPy, the word *array* is used, as it can represent both a single vector or a matrix, or even higher-order data! The key distinction is the `shape` and `ndims`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we can see that $\\boldsymbol{u}$ has one dimension (`u.ndim`), and has a shape indicating it has 3 values in that one dimension.\n",
    "\n",
    "In contrast, $X$ has two dimensions (`X.ndim`), it has 3 rows, and each row has 2 columns. There are six values total:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercises\n",
    "\n",
    "1. Create an array representing the following matrix:\n",
    "    $ \\begin{bmatrix}\n",
    "    10 & 20 & 30 \\\\\n",
    "    40 & 50 & 60 \n",
    "    \\end{bmatrix}  $\n",
    "2. In the Linear Regression Model, does the value of $\\beta$ represent a matrix or vector? Hint: Look up the greek alphabet and determine if it is an uppercase or lowercase letter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[10,20,30],[40,50,60]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beta represents a one-dimensional array or vector."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*For solutions, see `solutions/an_array.py`*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with matrices\n",
    "\n",
    "Matrix algebra follows different rules to normal algebra, but it is internally consistent and produces a wide range of benefits. First, a bit more terminology:\n",
    "\n",
    "$ \\begin{bmatrix}\n",
    "a_{1, 1} & a_{1, 2} & a_{1, 3} \\\\\n",
    "a_{2, 1} & a_{2, 2} & a_{2, 3} \n",
    "\\end{bmatrix}  $\n",
    "\n",
    "In this matrix, we use the subscripts identify the position of the values. Consider this matrix:\n",
    "\n",
    "$ X = \\begin{bmatrix}\n",
    "1 & 2 \\\\\n",
    "3 & 4 \\\\\n",
    "5 & 6 \n",
    "\\end{bmatrix}  $\n",
    "\n",
    "Here, the value $5$ is in the third row and first position, so it's position is $(3, 1)$. Let's look at this in code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[2, 0]  # Huh!?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While the numbering doesn't matter for any of the math we will see in the future, just keep in mind this general pattern:\n",
    "\n",
    "*In mathematics, we start counting from 1. In Python (and most programming languages), we start counting from zero.*\n",
    "\n",
    "This can trip up careful examination of the code. Luckily, as you get more familiar working with matrices, you worry less about accessing individual values inside the matrix, and more about how the matrices fit together.\n",
    "\n",
    "Next, let's look at the most basic operations in matrix algebra, between a scalar and a matrix or vector. Multiplying a matrix or a vector by a scalar simply does that operation on every element inside the matrix/vector, known as an *elementwise* operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4],\n",
       "       [ 6,  8],\n",
       "       [10, 12]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X * 2  # Multiplies every value inside X by 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 5],\n",
       "       [6, 7],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X + 3  # Adds 3 to every value inside X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.1, 0.2],\n",
       "       [0.3, 0.4],\n",
       "       [0.5, 0.6]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X / 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-99, -98],\n",
       "       [-97, -96],\n",
       "       [-95, -94]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X - 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the shape of the matrix doesn't change (we will see this happen next) when doing operations with scalars like this.\n",
    "\n",
    "The most impactful matrix algebra method is known as the *dot product*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1, 2, 3],\n",
    "              [4, 5, 6]])\n",
    "B = np.array([[10, 20],\n",
    "              [30, 40],\n",
    "              [50, 60]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[220, 280],\n",
       "       [490, 640]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.dot(B)  # If you are using Python 3.5+, try: A @ B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[220, 280],\n",
       "       [490, 640]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A@B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dot product has a key requirement. The \"inner dimensions\" must match. In the above examine, we are computing the dot product of $A$ and $B$. The order is important. $A$ has a shape of 2 by 3, and $B$ has a shape of 3 by 2. The \"inner values\", i.e. 3, match, so we can compute the dot product.\n",
    "\n",
    "This operation, in contrast, doesn't work, because $C$ is of shape 4 by 3, and the inner dimension doesn't match:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Could not compute dot product of matrices. Error was:\n",
      "shapes (2,3) and (4,3) not aligned: 3 (dim 1) != 4 (dim 0)\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    C = np.arange(12).reshape(4, 3)\n",
    "    A.dot(C)\n",
    "except ValueError as e:\n",
    "    print(\"Could not compute dot product of matrices. Error was:\")\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a dot product, the resulting matrix will be the size of the outer dimensions. In our previous (working) example, $AB$, the outer dimensions were both 2, so the resulting value was a 2 by 2 matrix.\n",
    "\n",
    "The values of the dot product are the *sum of the products* from the original two matrices, from the row of the first matrix and the column of the second matrix. In other words, for position (i, j) in the dot product, we get the ith row from the first matrix, and the jth column of the second matrix. For our example $AB$, and for position (2, 1) of the dot product, the second row of $A$ is $[4, 5, 6]$ and the first column of $B$ is $[10, 30, 50]$. We then sum the products of the individual values:\n",
    "\n",
    "$result = 4 \\times 10 + 5 \\times 30 + 6 \\times 50 = 490$\n",
    "\n",
    "We repeat this process for every row/column combination, resulting in the dot product matrix, obtaining the result we saw above.\n",
    "\n",
    "When we compute the dot product including a vector, we need to make the distinction between a *row vector* and a *column vector*. In short, a *row vector* can be thought of as a matrix with one row, and a *column vector* as a matrix with one column. From here, the rules are the same as above (i.e. the inner dimensions must match and so on, just some of those dimension values are 1s).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V1 = np.array([[10, 20, 30]])  # Note the double brackets, which create a two dimensional array\n",
    "V1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2200, 2800]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V1.dot(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2200, 2800]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matmul(V1,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10],\n",
       "       [20],\n",
       "       [30]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V1.transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercises\n",
    "\n",
    "1. Create a column vector `V2` such that the value `B.dot(V2)` can be computed. \n",
    "2. What is the dot product when all values in `V2` are ones?\n",
    "3. You can transpose any NumPy array with two dimensions or more by calling `X.transpose()` or `X.T`. What does this function do? Hint: Look at the shape of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dot product is the sum of the rows of B when V2 is a column vector of ones. Transposing reverses the dimensions.\n"
     ]
    }
   ],
   "source": [
    "V2 = np.array([[1], [1]])\n",
    "B.dot(V2)\n",
    "print(\"The dot product is the sum of the rows of B when V2 is a column vector of ones. Transposing reverses the dimensions.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*For solutions, see `solutions/matrix_products.py`*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix algebra terminology and properties\n",
    "\n",
    "There are quite a few bits of terminology that are important to know before going forward:\n",
    "\n",
    "* **square matrix**: A matrix where the number of rows is equal to the number of columns\n",
    "* **diagonal matrix**: A square matrix, where only values on the diagonal are non-zero and all other values are zero. That is, for value in position (i, j), it is zero if $i\\neq j$, and *may be non-zero* only if $i=j$\n",
    "* **identity matrix**: A diagonal matrix where *all* diagonal elements are 1. It is denoted as $I$, and usually the size is implied by the context (i.e. if you are computing the dot product $XI$, then $I$ will be a square matrix with the size of the second dimension of $X$).\n",
    "* **scalar matrix**: A diagonal matrix where *all* diagonal elements are some scalar value. Its size too can often be implied by the context.\n",
    "* **transpose**: rotating a matrix 90°, denoted by a quote symbol. That is, the transpose of $A$ is $A'$, and it has values such that $A_{i, j} = A'_{j, i}$. The transpose of the transpose of a matrix is equal to the original matrix, i.e. $A'' = A$.\n",
    "* **symmetric matrix**: A matrix that is equal to its transpose.\n",
    "* **null matrix/vector**: A matrix/vector where all values are 0. Its size is often implied from the context.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercises\n",
    "\n",
    "1. Use the `np.arange` and `np.reshape` functions to create a square matrix\n",
    "2. Use the `np.diag` function to create a diagonal matrix\n",
    "3. Use the `np.eye` function to create an identity matrix\n",
    "4. Create a scalar matrix\n",
    "5. Use the `np.zeros` function to create a null matrix of size 4 by 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "[[3 0 0 0]\n",
      " [0 3 0 0]\n",
      " [0 0 4 0]\n",
      " [0 0 0 5]]\n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n",
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "[[0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "SQ = np.arange(9).reshape([3,3])\n",
    "print(SQ)\n",
    "\n",
    "DG = np.diag([3,3,4,5])\n",
    "print(DG)\n",
    "\n",
    "I = np.eye(3)\n",
    "print(I)\n",
    "\n",
    "SC = I*9\n",
    "print(C)\n",
    "\n",
    "Z = np.zeros([4,5])\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*For solutions, see `solutions/matrix_terminology.py`*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix inversion\n",
    "\n",
    "The inverse of a matrix ($A$) is a matrix ($A^{-1}$) satisfying the equation $A^{-1}A = AA^{-1} = I$, remembering that $I$ is the identity matrix, a square matrix with all ones on the diagonal, and zeros elsewhere.\n",
    "\n",
    "If $A$ is a matrix of size $(n, m)$, then $I$ must be of size $(n, n)$. This is due to the dot product, meaning the inverse must be of size $(m, n)$ to compute the dot product in the first place. However, the inverse can only be computed for square matrices. The size of $A$ in this process will be $(n, n)$, so the inverse must also be $(n, n)$.\n",
    "\n",
    "Not every square matrix has an inverse. Looking at how to compute the inverse of a matrix will take us a little too far off topic for now. To investigate this further, start with this website from Wolfram: http://mathworld.wolfram.com/MatrixInverse.html\n",
    "\n",
    "We can compute the inverse using the `np.linalg.inv` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "D = A.dot(B)  # Note: D is square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "D_inverse = np.linalg.inv(D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.17777778, -0.07777778],\n",
       "       [-0.13611111,  0.06111111]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D_inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.00000000e+00, -1.66533454e-15],\n",
       "       [-7.10542736e-15,  1.00000000e+00]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D.dot(D_inverse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False],\n",
       "       [False, False]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Due to floating point math on computers, the values are close-to-but-not-exactly the identity matrix\n",
    "D.dot(D_inverse) == np.eye(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This function can help us do this comparison\n",
    "np.allclose(D.dot(D_inverse), np.eye(2))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multivariate OLS derivation\n",
    "\n",
    "Now that we have an understanding of matrix algebra, we can review our model for the Linear Regression model to incorporate multiple values. That said, what does our input data actually look like?\n",
    "\n",
    "We often use $X$ as our set of independent variables. It is a carefully constructed matrix, with size $n$ by $k$, where $n$ is the number of samples, and $k$ is the number of measurements *per sample*. It is critically important that samples and measurement types are aligned. That is, all values for row $i$ must correspond to the same sample $i$, and all values in column $j$ must correspond to the same measurement type for each sample. Therefore, the value in $X_{i, j}$ is measurement type $j$ for sample $i$.\n",
    "\n",
    "As an example, a sample could be a given day. A measurement type could be \"closing price of IBM\". Therefore, the corresponding value would be the closing price of IBM on that given day. Another measurement for that day could be \"number of trades for MSFT\". Another could be temperature. These multiple measurements of the same sample would appear in the same row. Each column would be the same *type* of measurement, for multiple samples.\n",
    "\n",
    "Additionally, it helps the Linear Regression model significantly to add a bias to the model. To do this, simply have one of the \"measurements\" (usually the first) simply always return the scalar 1. That makes your first column in $X$ just ones, and then the actual measurements take up the rest of the columns. To visualise why this is important, consider the following two models:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(-100, 100, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x244f599fbd0>]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Without a \"1\" bias column\n",
    "gradient = 3\n",
    "y1 = x * gradient\n",
    "\n",
    "# Plot the origin axes in red\n",
    "plt.plot(x, np.zeros(len(x)), 'r-', alpha=0.5)\n",
    "plt.plot(np.zeros(len(y1)), y1, 'r-', alpha=0.5)\n",
    "\n",
    "# Plot the data in blue\n",
    "plt.plot(x, y1, 'b-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above plot, we can change the gradient, but the line must go through the origin (try it!). If we add a bias, we can then have lines that do not go through the origin:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x244f7bd19d0>]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gradient = 3\n",
    "bias = 60\n",
    "\n",
    "y2 = gradient * x + bias\n",
    "\n",
    "# Plot the origin axes in red\n",
    "plt.plot(x, np.zeros(len(x)), 'r-', alpha=0.5)\n",
    "plt.plot(np.zeros(len(y2)), y2, 'r-', alpha=0.5)\n",
    "\n",
    "# Plot the data in blue\n",
    "plt.plot(x, y2, 'b-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This result is true too of higher-dimensional data. This gives our model much more predictive power, simply by adding ones to our matrix! The $\\beta$ values for this constant column are learned in the same way that the other variables.\n",
    "\n",
    "Now that we have the format for $X$, let's look at the shape of the other parts of the Linear Model. As a reminder, we have denoted the shape of $X$ as an $n$ by $k$ matrix, where $n$ is the number of samples and $k$ is the number of measurements (also called \"features\").\n",
    "\n",
    "* $\\boldsymbol{y}$ is a column vector with shape $n$ by 1. It is the predicted value, for each sample.\n",
    "* $\\beta$ is a column vector with shape $k$ by 1. It is the value we multiply each measurement by, i.e. each measurement's \"weight\"\n",
    "* $\\boldsymbol{u}$ is the error term for the prediction of each sample. It therefore has shape $n$ by 1.\n",
    "\n",
    "Using this information and our new knowledge of matrix algebra, we can derive the OLS Estimator for multivariate OLS, where $X$ contains multiple measurements:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{align*}\n",
    "u'u & = (y - Xb)'(y - Xb) \\\\\n",
    "    & = y'y - y'Xb - b'X'y + b'X'Xb \\\\\n",
    "    & = y'y - 2b'X'y + b'X'Xb\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "\n",
    "Setting $\\frac{ \\partial(\\boldsymbol{u'}\\boldsymbol{u})}{ \\partial\\beta} = 0$ yields:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "0 &= -2X'y + 2X'Xb \\\\\n",
    "b &= (X'X)^{-1}X'y\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now have a look at how to do multivariate OLS within code, in the `statsmodels` package, using two interfaces, the functional and the formula interface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, get the data - interest rates, inflation and AUD from Quandl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "import quandl\n",
    "\n",
    "interest_rates = quandl.get(\"RBA/F13_FOOIRATCR\")\n",
    "interest_rates = interest_rates[interest_rates.columns[0]]  # Extract the first column, whatever it is called\n",
    "interest_rates.name = \"InterestRate\"  # Rename, as the original had a long name. Hint: don't use spaces or special chars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Date\n",
       "1990-01-31    17.0\n",
       "1990-02-28    16.5\n",
       "1990-03-31    16.5\n",
       "1990-04-30    15.0\n",
       "1990-05-31    15.0\n",
       "Name: InterestRate, dtype: float64"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interest_rates.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "inflation = quandl.get(\"RBA/G01_GCPIAGSAQP\")\n",
    "inflation.columns = ['Inflation']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "inflation = inflation.iloc[:, 0]  # Another way to achieve the same \"get the first column\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Date\n",
       "1982-06-30    2.5\n",
       "1982-09-30    3.5\n",
       "1982-12-31    2.7\n",
       "1983-03-31    2.4\n",
       "1983-06-30    2.2\n",
       "Name: Inflation, dtype: float64"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inflation.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "au_dollar = quandl.get(\"BUNDESBANK/BBEX3_M_AUD_USD_CM_AC_A01\")['Value']\n",
    "au_dollar.name = \"AUDUSD\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Date\n",
       "1974-01-31    1.4875\n",
       "1974-02-28    1.4875\n",
       "1974-03-31    1.4875\n",
       "1974-04-30    1.4875\n",
       "1974-05-31    1.4875\n",
       "Name: AUDUSD, dtype: float64"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "au_dollar.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Join data together to create a dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.concat([interest_rates, inflation, au_dollar], axis=1)  # Combines multiple series into a DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.dropna(inplace=True)\n",
    "len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>InterestRate</th>\n",
       "      <th>Inflation</th>\n",
       "      <th>AUDUSD</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1990-03-31</td>\n",
       "      <td>16.5</td>\n",
       "      <td>1.6</td>\n",
       "      <td>0.7542</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1990-06-30</td>\n",
       "      <td>15.0</td>\n",
       "      <td>1.8</td>\n",
       "      <td>0.7890</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1990-09-30</td>\n",
       "      <td>14.0</td>\n",
       "      <td>0.9</td>\n",
       "      <td>0.8265</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1990-12-31</td>\n",
       "      <td>12.0</td>\n",
       "      <td>2.4</td>\n",
       "      <td>0.7733</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1991-03-31</td>\n",
       "      <td>12.0</td>\n",
       "      <td>-0.2</td>\n",
       "      <td>0.7752</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            InterestRate  Inflation  AUDUSD\n",
       "Date                                       \n",
       "1990-03-31          16.5        1.6  0.7542\n",
       "1990-06-30          15.0        1.8  0.7890\n",
       "1990-09-30          14.0        0.9  0.8265\n",
       "1990-12-31          12.0        2.4  0.7733\n",
       "1991-03-31          12.0       -0.2  0.7752"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using the interest rate and USD conversion to predict Inflation\n",
    "X = data[[\"InterestRate\", \"AUDUSD\"]]\n",
    "y = data['Inflation']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\marin\\Anaconda3\\lib\\site-packages\\numpy\\core\\fromnumeric.py:2389: FutureWarning: Method .ptp is deprecated and will be removed in a future version. Use numpy.ptp instead.\n",
      "  return ptp(axis=axis, out=out, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "import statsmodels.api as sm\n",
    "# Nice helper function from statsmodels for adding a bias/constant\n",
    "X = sm.add_constant(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>const</th>\n",
       "      <th>InterestRate</th>\n",
       "      <th>AUDUSD</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1990-03-31</td>\n",
       "      <td>1.0</td>\n",
       "      <td>16.5</td>\n",
       "      <td>0.7542</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1990-06-30</td>\n",
       "      <td>1.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>0.7890</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1990-09-30</td>\n",
       "      <td>1.0</td>\n",
       "      <td>14.0</td>\n",
       "      <td>0.8265</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1990-12-31</td>\n",
       "      <td>1.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.7733</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1991-03-31</td>\n",
       "      <td>1.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.7752</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            const  InterestRate  AUDUSD\n",
       "Date                                   \n",
       "1990-03-31    1.0          16.5  0.7542\n",
       "1990-06-30    1.0          15.0  0.7890\n",
       "1990-09-30    1.0          14.0  0.8265\n",
       "1990-12-31    1.0          12.0  0.7733\n",
       "1991-03-31    1.0          12.0  0.7752"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"simpletable\">\n",
       "<caption>OLS Regression Results</caption>\n",
       "<tr>\n",
       "  <th>Dep. Variable:</th>        <td>Inflation</td>    <th>  R-squared:         </th> <td>   0.102</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Model:</th>                   <td>OLS</td>       <th>  Adj. R-squared:    </th> <td>   0.087</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Method:</th>             <td>Least Squares</td>  <th>  F-statistic:       </th> <td>   6.929</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Date:</th>             <td>Tue, 15 Feb 2022</td> <th>  Prob (F-statistic):</th>  <td>0.00141</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Time:</th>                 <td>15:22:00</td>     <th>  Log-Likelihood:    </th> <td> -100.11</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>No. Observations:</th>      <td>   125</td>      <th>  AIC:               </th> <td>   206.2</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Df Residuals:</th>          <td>   122</td>      <th>  BIC:               </th> <td>   214.7</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Df Model:</th>              <td>     2</td>      <th>                     </th>     <td> </td>   \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Covariance Type:</th>      <td>nonrobust</td>    <th>                     </th>     <td> </td>   \n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "        <td></td>          <th>coef</th>     <th>std err</th>      <th>t</th>      <th>P>|t|</th>  <th>[0.025</th>    <th>0.975]</th>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>const</th>        <td>    0.2446</td> <td>    0.308</td> <td>    0.794</td> <td> 0.429</td> <td>   -0.365</td> <td>    0.855</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>InterestRate</th> <td>    0.0646</td> <td>    0.017</td> <td>    3.720</td> <td> 0.000</td> <td>    0.030</td> <td>    0.099</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>AUDUSD</th>       <td>    0.0730</td> <td>    0.385</td> <td>    0.190</td> <td> 0.850</td> <td>   -0.688</td> <td>    0.834</td>\n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "  <th>Omnibus:</th>       <td>49.562</td> <th>  Durbin-Watson:     </th> <td>   1.909</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Prob(Omnibus):</th> <td> 0.000</td> <th>  Jarque-Bera (JB):  </th> <td> 455.460</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Skew:</th>          <td> 0.997</td> <th>  Prob(JB):          </th> <td>1.25e-99</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Kurtosis:</th>      <td>12.136</td> <th>  Cond. No.          </th> <td>    56.6</td>\n",
       "</tr>\n",
       "</table><br/><br/>Warnings:<br/>[1] Standard Errors assume that the covariance matrix of the errors is correctly specified."
      ],
      "text/plain": [
       "<class 'statsmodels.iolib.summary.Summary'>\n",
       "\"\"\"\n",
       "                            OLS Regression Results                            \n",
       "==============================================================================\n",
       "Dep. Variable:              Inflation   R-squared:                       0.102\n",
       "Model:                            OLS   Adj. R-squared:                  0.087\n",
       "Method:                 Least Squares   F-statistic:                     6.929\n",
       "Date:                Tue, 15 Feb 2022   Prob (F-statistic):            0.00141\n",
       "Time:                        15:22:00   Log-Likelihood:                -100.11\n",
       "No. Observations:                 125   AIC:                             206.2\n",
       "Df Residuals:                     122   BIC:                             214.7\n",
       "Df Model:                           2                                         \n",
       "Covariance Type:            nonrobust                                         \n",
       "================================================================================\n",
       "                   coef    std err          t      P>|t|      [0.025      0.975]\n",
       "--------------------------------------------------------------------------------\n",
       "const            0.2446      0.308      0.794      0.429      -0.365       0.855\n",
       "InterestRate     0.0646      0.017      3.720      0.000       0.030       0.099\n",
       "AUDUSD           0.0730      0.385      0.190      0.850      -0.688       0.834\n",
       "==============================================================================\n",
       "Omnibus:                       49.562   Durbin-Watson:                   1.909\n",
       "Prob(Omnibus):                  0.000   Jarque-Bera (JB):              455.460\n",
       "Skew:                           0.997   Prob(JB):                     1.25e-99\n",
       "Kurtosis:                      12.136   Cond. No.                         56.6\n",
       "==============================================================================\n",
       "\n",
       "Warnings:\n",
       "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n",
       "\"\"\""
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fit an OLS model and get a summary\n",
    "est = sm.OLS(y, X).fit()\n",
    "\n",
    "est.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll come back to what these values mean in the next notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = est.predict(X)\n",
    "y_pred.name = \"PredictedInflation\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1ce421e13c8>"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pd.concat([y, y_pred], axis=1).plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our OLS model is able to roughly model the general trend of the inflation!\n",
    "\n",
    "<div class=\"alert alert-warning\">\n",
    "    Don't get too excited about the quality of that prediction! We are currently overfitting that data, so we haven't determined the actual predictive power of the model. In short, to evaluate your model you must evaluate using data the model hasn't seen before.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercises\n",
    "\n",
    "Perform a more robust evaluation of the model by following these steps:\n",
    "\n",
    "1. Split your input data (the `data` variable) into two-thirds training and one-third testing.\n",
    "2. Fit the model *only* on the training data\n",
    "3. Predict the testing data and evaluate the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1ce42ab0608>"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "training_data, testing_data = train_test_split(data, test_size=0.3, random_state=25)\n",
    "\n",
    "# Fit an OLS model and get a summary\n",
    "est_mod = sm.OLS(training_data['Inflation'], training_data[[\"InterestRate\", \"AUDUSD\"]]).fit()\n",
    "\n",
    "est_mod.summary()\n",
    "\n",
    "test_pred = est_mod.predict(testing_data[[\"InterestRate\", \"AUDUSD\"]])\n",
    "test_pred.name = \"TestDataPredictedInflation\"\n",
    "\n",
    "pd.concat([testing_data['Inflation'], test_pred], axis=1).plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*For solutions, see `solutions/ols_train_test.py`*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using the Formula interface\n",
    "\n",
    "The second method of performing multivariate OLS using statsmodels is using the formula interface. It is faster to develop using the formula interface, but has it's own mini \"R-like\" language to learn to create the formulas. That said, it automatically does things like expand multiplied variables, adds constants and can perform basic computations (try calling `np.log` inside the formula!).\n",
    "\n",
    "The Formula interface is likely better for most development needs. However if you need fine grained control over the variables, you may need to drop back to the previous object-oriented interface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statsmodels.formula.api as smf\n",
    "est = smf.ols(formula='Inflation ~ InterestRate + AUDUSD', data=data).fit()  # Adds the constant for us"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1ce42b86f48>"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_pred = est.predict(X)\n",
    "y_pred.name = \"PredictedInflation\"\n",
    "pd.concat([y, y_pred], axis=1).plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using this method, we can also more easily modify the formula, for instance, to incorporate a new feature which is the interaction between Interest Rate and AUD/USD:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statsmodels.formula.api as smf\n",
    "est = smf.ols(formula='Inflation ~ InterestRate + AUDUSD + (InterestRate * AUDUSD)', \n",
    "              data=data).fit()  # Does the constant for us"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1ce42c42a08>"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_pred = est.predict(X)\n",
    "y_pred.name = \"PredictedInflation\"\n",
    "pd.concat([y, y_pred], axis=1).plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercises\n",
    "\n",
    "1. Perform the same train/test split that we did for the previous exercises\n",
    "2. Review the documentation for the formula API: https://www.statsmodels.org/dev/example_formulas.html\n",
    "3. Try a few different combinations of the input parameters to get better predictive power."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1ce42d2c5c8>"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "training_data, testing_data = train_test_split(data, test_size=0.3, random_state=25)\n",
    "\n",
    "# Fit an OLS model and get a summary\n",
    "est_mod2 = smf.ols(formula='Inflation ~ InterestRate + AUDUSD + (InterestRate * AUDUSD)', \n",
    "              data=data).fit() \n",
    "\n",
    "est_mod2.summary()\n",
    "\n",
    "test_pred2 = est_mod2.predict(testing_data[[\"InterestRate\", \"AUDUSD\"]])\n",
    "test_pred2.name = \"Test2DataPredictedInflation\"\n",
    "\n",
    "\n",
    "pd.concat([testing_data['Inflation'], test_pred2], axis=1).plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*For solutions, see `solutions/statsmodels_formula_ols.py`*"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
